//! Rust Web服务演示项目主入口
//! 
//! 这是一个完整的Rust Web服务演示项目，包含：
//! - 用户管理API（注册、登录、登出）
//! - JWT身份认证
//! - PostgreSQL数据库集成
//! - Redis缓存
//! - WebSocket实时通信
//! - TCP Socket服务器
//! - 监控和日志
//! 
//! 技术栈：
//! - Web框架: Axum + Tokio
//! - 数据库: PostgreSQL + SQLx
//! - 缓存: Redis
//! - 认证: JWT
//! - 实时通信: WebSocket + TCP Socket
//! - 部署: Docker + Kubernetes
//! - 监控: Prometheus + Grafana

use axum::{
    routing::{get, post},
    Router,
};
use std::net::SocketAddr;
use tower::ServiceBuilder;
use tower_http::{
    trace::TraceLayer,
    cors::CorsLayer,
};

// 导入我们的模块
mod config;
mod database;
mod auth;
mod cache;
mod models;
mod handlers;
mod middleware;
mod websocket;
mod tcp;
mod monitoring;
mod errors;

// 重新导出常用类型
use crate::{
    config::AppConfig,
    database::DatabaseManager,
    cache::CacheManager,
    auth::AuthService,
    websocket::WebSocketManager,
    tcp::TcpServer,
    monitoring::{Metrics, start_monitoring},
    errors::AppResult,
    handlers::{health, auth as auth_handlers, users as user_handlers},
};

/// 应用程序状态
/// 
/// 这个结构体包含了应用程序运行所需的所有共享状态：
/// - 数据库连接池
/// - Redis连接池
/// - 认证服务
/// - WebSocket连接管理器
/// - 监控指标
#[derive(Clone)]
pub struct AppState {
    pub db: DatabaseManager,
    pub cache: CacheManager,
    pub auth: AuthService,
    pub websocket: WebSocketManager,
    pub metrics: Metrics,
    pub config: AppConfig,
}

impl AppState {
    /// 创建新的应用程序状态
    /// 
    /// # 参数
    /// - `config`: 应用程序配置
    /// 
    /// # 返回值
    /// - `Result<Self, AppError>`: 创建成功返回AppState，失败返回错误
    pub async fn new(config: AppConfig) -> AppResult<Self> {
        tracing::info!("🚀 初始化应用程序状态...");

        // 初始化数据库管理器
        let db = DatabaseManager::new(&config.database).await?;
        tracing::info!("✅ 数据库连接池初始化完成");

        // 初始化缓存管理器
        let cache = CacheManager::new(&config.redis).await?;
        tracing::info!("✅ Redis连接池初始化完成");

        // 初始化认证服务
        let auth = AuthService::new(&config.jwt, db.clone());
        tracing::info!("✅ JWT认证服务初始化完成");

        // 初始化WebSocket管理器
        let websocket = WebSocketManager::new();
        tracing::info!("✅ WebSocket管理器初始化完成");

        // 初始化监控指标
        let metrics = Metrics::new()?;
        tracing::info!("✅ 监控指标初始化完成");

        Ok(Self {
            db,
            cache,
            auth,
            websocket,
            metrics,
            config,
        })
    }

    /// 预热应用程序
    /// 
    /// 在启动后执行一些预热操作，如数据库连接测试、缓存预热等
    pub async fn warmup(&self) -> AppResult<()> {
        tracing::info!("🔥 开始应用程序预热...");

        // 测试数据库连接
        self.db.health_check().await?;
        tracing::info!("✅ 数据库连接测试通过");

        // 测试Redis连接
        self.cache.health_check().await?;
        tracing::info!("✅ Redis连接测试通过");

        // 预热缓存（如果有必要的话）
        // self.cache.warmup().await?;

        tracing::info!("✅ 应用程序预热完成");
        Ok(())
    }
}

/// 主函数
/// 
/// 这是应用程序的入口点，负责：
/// 1. 初始化日志系统
/// 2. 加载配置
/// 3. 创建应用程序状态
/// 4. 构建路由
/// 5. 启动HTTP服务器
/// 6. 启动WebSocket服务器
/// 7. 启动TCP服务器
/// 8. 启动监控服务
#[tokio::main]
async fn main() -> AppResult<()> {
    // 初始化日志系统
    init_logging()?;
    tracing::info!("🎯 Rust Web服务演示项目启动中...");

    // 加载配置
    let config = AppConfig::load()?;
    tracing::info!("📋 配置加载完成");

    // 创建应用程序状态
    let state = AppState::new(config.clone()).await?;
    
    // 预热应用程序
    state.warmup().await?;

    // 构建HTTP路由
    let app = create_router(state.clone());

    // 启动HTTP服务器
    let http_server = start_http_server(app, config.server.clone());
    
    // 启动WebSocket服务器
    let websocket_server = start_websocket_server(state.clone());
    
    // 启动TCP服务器
    let tcp_server = start_tcp_server(state.clone());
    
    // 启动监控服务
    let monitoring_server = start_monitoring(state.metrics.clone());

    tracing::info!("🌟 所有服务启动完成！");
    tracing::info!("📡 HTTP服务器: http://{}:{}", config.server.host, config.server.port);
    tracing::info!("🔌 WebSocket服务器: ws://{}:{}", config.server.host, config.websocket.port);
    tracing::info!("🌐 TCP服务器: tcp://{}:{}", config.server.host, config.tcp.port);
    tracing::info!("📊 监控服务: http://{}:{}", config.server.host, config.monitoring.port);

    // 等待所有服务完成
    tokio::join!(
        http_server,
        websocket_server,
        tcp_server,
        monitoring_server
    );

    Ok(())
}

/// 初始化日志系统
/// 
/// 配置结构化日志输出，支持不同环境的不同日志级别和格式
fn init_logging() -> AppResult<()> {
    // 设置默认日志级别
    if std::env::var("RUST_LOG").is_err() {
        std::env::set_var("RUST_LOG", "info");
    }

    // 初始化日志订阅器
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
        .with_target(true)
        .with_thread_ids(true)
        .with_thread_names(true)
        .with_file(true)
        .with_line_number(true)
        .json() // 使用JSON格式，便于日志收集系统处理
        .init();

    tracing::info!("📝 日志系统初始化完成");
    Ok(())
}

/// 创建HTTP路由
/// 
/// 构建应用程序的HTTP路由，包括：
/// - 健康检查端点
/// - 认证相关端点（登录、注册、登出）
/// - 用户管理端点
/// - WebSocket升级端点
/// - 监控指标端点
fn create_router(state: AppState) -> Router {
    Router::new()
        // 健康检查端点
        .route("/", get(health::root))
        .route("/health", get(health::health_check))
        
        // 认证相关端点
        .route("/api/v1/auth/register", post(auth_handlers::register))
        .route("/api/v1/auth/login", post(auth_handlers::login))
        .route("/api/v1/auth/logout", post(auth_handlers::logout))
        .route("/api/v1/auth/me", get(auth_handlers::get_current_user))
        
        // 用户管理端点（需要认证）
        .route("/api/v1/users", get(user_handlers::get_users))
        .route("/api/v1/users/:id", get(user_handlers::get_user))
        .route("/api/v1/users/:id", post(user_handlers::update_user))
        .route("/api/v1/users/:id", axum::routing::delete(user_handlers::delete_user))
        
        // WebSocket端点
        .route("/ws", get(websocket::websocket_handler))
        
        // 监控指标端点
        .route("/metrics", get(monitoring::metrics_handler))
        
        // 添加中间件
        .layer(
            ServiceBuilder::new()
                // 请求追踪中间件
                .layer(TraceLayer::new_for_http())
                // CORS中间件
                .layer(CorsLayer::permissive())
                // 请求ID中间件
                .layer(axum::middleware::from_fn(middleware::request_id_middleware))
                // 日志中间件
                .layer(axum::middleware::from_fn(middleware::logging_middleware))
                // 监控指标中间件
                .layer(axum::middleware::from_fn_with_state(
                    state.metrics.clone(),
                    middleware::metrics_middleware,
                ))
        )
        // 添加应用程序状态
        .with_state(state)
}

/// 启动HTTP服务器
/// 
/// # 参数
/// - `app`: HTTP应用路由
/// - `config`: 服务器配置
/// 
/// # 返回值
/// - `tokio::task::JoinHandle<Result<(), hyper::Error>>`: 服务器任务句柄
async fn start_http_server(app: Router, config: config::ServerConfig) -> tokio::task::JoinHandle<Result<(), std::io::Error>> {
    tokio::spawn(async move {
        let addr = SocketAddr::from(([0, 0, 0, 0], config.port));
        let listener = tokio::net::TcpListener::bind(addr).await?;
        
        tracing::info!("🌐 HTTP服务器启动在 {}", addr);
        axum::serve(listener, app).await
    })
}

/// 启动WebSocket服务器
/// 
/// # 参数
/// - `state`: 应用程序状态
/// 
/// # 返回值
/// - `tokio::task::JoinHandle<Result<(), Box<dyn std::error::Error + Send + Sync>>>`: 服务器任务句柄
async fn start_websocket_server(state: AppState) -> tokio::task::JoinHandle<Result<(), Box<dyn std::error::Error + Send + Sync>>> {
    tokio::spawn(async move {
        let tcp_server = TcpServer::new_websocket(&state.config.websocket).await?;
        tcp_server.run_websocket(state).await
    })
}

/// 启动TCP服务器
/// 
/// # 参数
/// - `state`: 应用程序状态
/// 
/// # 返回值
/// - `tokio::task::JoinHandle<Result<(), Box<dyn std::error::Error + Send + Sync>>>`: 服务器任务句柄
async fn start_tcp_server(state: AppState) -> tokio::task::JoinHandle<Result<(), Box<dyn std::error::Error + Send + Sync>>> {
    tokio::spawn(async move {
        let tcp_server = TcpServer::new_tcp(&state.config.tcp).await?;
        tcp_server.run_tcp(state).await
    })
}
